#### 16.7.1 Machine-Independent Predicates

These are the generic predicates available to all back ends. They are defined in `recog.c`. The first category of predicates allow only constant, or immediate, operands.

— Function: immediate_operand

> This predicate allows any sort of constant that fits in mode. It is an appropriate choice for instructions that take operands that must be constant.

— Function: const_int_operand

> This predicate allows any `CONST_INT` expression that fits in mode. It is an appropriate choice for an immediate operand that does not allow a symbol or label.

— Function: const_double_operand

> This predicate accepts any `CONST_DOUBLE` expression that has exactly mode. If mode is `VOIDmode`, it will also accept `CONST_INT`. It is intended for immediate floating point constants.

The second category of predicates allow only some kind of machine register.

— Function: register_operand

> This predicate allows any `REG` or `SUBREG` expression that is valid for mode. It is often suitable for arithmetic instruction operands on a RISC machine.

— Function: pmode_register_operand

> This is a slight variant on `register_operand` which works around a limitation in the machine-description reader.

>               (match_operand n "pmode_register_operand" constraint)

> means exactly what

>               (match_operand:P n "register_operand" constraint)

> would mean, if the machine-description reader accepted ``:P`' mode suffixes. Unfortunately, it cannot, because `Pmode` is an alias for some other mode, and might vary with machine-specific options. See Misc.

— Function: scratch_operand

> This predicate allows hard registers and `SCRATCH` expressions, but not pseudo-registers. It is used internally by `match_scratch`; it should not be used directly.

The third category of predicates allow only some kind of memory reference.

— Function: memory_operand

> This predicate allows any valid reference to a quantity of mode mode in memory, as determined by the weak form of `GO_IF_LEGITIMATE_ADDRESS` (see Addressing Modes).

— Function: address_operand

> This predicate is a little unusual; it allows any operand that is a valid expression for the address of a quantity of mode mode, again determined by the weak form of `GO_IF_LEGITIMATE_ADDRESS`. To first order, if ``(mem:mode (exp))`' is acceptable to `memory_operand`, then exp is acceptable to `address_operand`. Note that exp does not necessarily have the mode mode.

— Function: indirect_operand

> This is a stricter form of `memory_operand` which allows only memory references with a `general_operand` as the address expression. New uses of this predicate are discouraged, because `general_operand` is very permissive, so it's hard to tell what an `indirect_operand` does or does not allow. If a target has different requirements for memory operands for different instructions, it is better to define target-specific predicates which enforce the hardware's requirements explicitly.

— Function: push_operand

> This predicate allows a memory reference suitable for pushing a value onto the stack. This will be a `MEM` which refers to `stack_pointer_rtx`, with a side-effect in its address expression (see Incdec); which one is determined by the `STACK_PUSH_CODE` macro (see Frame Layout).

— Function: pop_operand

> This predicate allows a memory reference suitable for popping a value off the stack. Again, this will be a `MEM` referring to `stack_pointer_rtx`, with a side-effect in its address expression. However, this time `STACK_POP_CODE` is expected.

The fourth category of predicates allow some combination of the above operands.

— Function: nonmemory_operand

> This predicate allows any immediate or register operand valid for mode.

— Function: nonimmediate_operand

> This predicate allows any register or memory operand valid for mode.

— Function: general_operand

> This predicate allows any immediate, register, or memory operand valid for mode.

Finally, there are two generic operator predicates.

— Function: comparison_operator

> This predicate matches any expression which performs an arithmetic comparison in mode; that is, `COMPARISON_P` is true for the expression code.

— Function: ordered_comparison_operator

> This predicate matches any expression which performs an arithmetic comparison in mode and whose expression code is valid for integer modes; that is, the expression code will be one of `eq`, `ne`, `lt`, `ltu`, `le`, `leu`, `gt`, `gtu`, `ge`, `geu`.